Gemba Labs

Fixing common high-resolution scaling issues for Windows 10 applications

John Miller — Sun, 08 Apr 2018 20:12:42 +0000

If you’ve spent any time on a newer, high resolution Windows 10 machine I’m sure you’ve come across many applications that don’t quite scale right. For example, at the recommended high-resolution settings on my Surface Book, SoapUI is pretty much unusable. Turns out that you can apply a setting to applications that force them to use system scaling.

Right-click the .exe and select properties. From there go to the Compatibility tab and apply the settings below.

Hope this helps someone else!

The post Fixing common high-resolution scaling issues for Windows 10 applications appeared first on Gemba Labs.

Creating Secure Volumes on Windows 10

John Miller — Sun, 08 Apr 2018 17:22:46 +0000

A feature of OSX that I appreciated was the ability to create a secured volume for storing personal documents. Since converting to Windows 10, I’ve found you can get the same feature using Bitlocker. I already have hard drive encryption enabled which gives you that first level of security, but having a password-protected volume on top for sensitive documents is even better.

To start, we need to create a VHD (virtual hard drive) by opening the Disk Management utility and selecting ‘Create VHD’ from the Action menu.

Next we need to configure a few settings for our VHD. Click the Browse button and choose a location and filename for your drive. Then specify the disk size. Since I’m only storing PDFs and spreadsheets, I’m going to make this one relatively small at 2GB. The standard VHD format will be fine and since I want optimal read\write performance I’m going to choose the fixed size hard drive type. This will cause the VHD file to consume the full allocated size on your physical hard drive. Alternatively, you can configure it dynamically expand which will allow it to grow to the maximum size as you add data to it. Good choice if you’re limited on hard drive space and not concerned about performance.

This will create a new disk in the management utility. Right click the disk name (‘Disk 1’ in my case) and select ‘Initialize Disk’. The default settings in the initialization window will work for us, go ahead and click OK.

Now that the disk has been initialized, we need to create a volume on it. Do that by right-clicking the ‘Unallocated’ disk block and select ‘New Simple Volume’. This will walk you through a wizard to configure the volume. For our purposes, we’ll want to format the drive as NTFS and give it a volume label.

Once it’s complete, an explorer window will appear listing our new disk.

Next we need to enable Bitlocker on the disk by right-clicking the disk and selecting ‘Turn on Bitlocker’. Specify a password for the drive and click next.

If you forget your password, you can still access your drive using the generated recovery key. You’ll need to save the key before moving on. If you have Bitlocker encryption enabled for your physical hard drive, you won’t be able to save it as a file on that drive. But you can choose to print the recovery key as a PDF within the print dialog window.

Last you’ll need to set the encryption mode. Since this drive will only be used on this device, we’ll select ‘New encryption mode’ since it provides the best level of encryption.

After the encryption process has completed we are ready to add our files to the drive. When we’re done working, we want to close it by right-clicking and selecting ‘Eject’.

To reopen the drive, double click on the VHD within Windows Explorer. It will reappear in your drive list but you will most likely get an error saying the drive is not accessible. Click OK to close the alert and then double-click the drive in your drive list.

After entering your password you will be able to work in the drive folder again.

Bitlocker works great for most cases, but if your looking for more security options or need to need a solution that works on other platforms you may want to consider an alternative tool such as Veracrypt. But for my needs, the built in Bitlocker features are perfect.

The post Creating Secure Volumes on Windows 10 appeared first on Gemba Labs.

Cross browser print image javascript

John Miller — Fri, 18 Sep 2015 14:00:32 +0000

Hiding sections of a page when printing is a fairly common and trivial task with the help of a little css. For example, hiding a page header and footer only takes a few lines.

[css] @media print {
.header, .footer {
display: none;
}
}[/css]

But what if you want to only print a single element, such as an image? You could take the above approach to hide all other elements and only allow the image to be displayed. An alternative approach is to use a little javascript to open the image in a new window and immediately trigger the window.print() method.

[js] $(‘#print-btn’).click(function () {
printImage(‘/path/to/image.png’);
return true;
});

function printImage(imagePath) {
var width = $(window).width() * 0.9;
var height = $(window).height() * 0.9;
var content = ‘’ +
‘’ +
‘’ +
‘’ +
‘’ +
‘’ +
‘’;
var options = "toolbar=no,location=no,directories=no,menubar=no,scrollbars=yes,width=" + width + ",height=" + height;
var printWindow = window.open(”, ‘print’, options);
printWindow.document.open();
printWindow.document.write(content);
printWindow.document.close();
printWindow.focus();
}[/js]

The above script opens a new (nearly fullscreen) window containing the image we want to print. Notice that the body tag has an onload attribute that set’s the window’s focus (needed to make IE happy), calls print, and immediately closes. This tells the window to close after the user exits the print dialog. Note that you could actually move the print() and close() calls to the parent window’s script, printWindow.print() and printWindow().close(). But I found that doing so caused Chrome to display the print window before the image had a chance to load, resulting in an empty page. The version seemed to pacify both Chrome and Internet Explorer.

The post Cross browser print image javascript appeared first on Gemba Labs.

gulp clean Error: ENOENT, lstat

John Miller — Wed, 16 Sep 2015 13:44:32 +0000

I have a gulp task that uses gulp-clean to wipe the contents of an output directory before other tasks are ran. It seemed to fail 50% of the time, throwing an exception with the message ‘Error: ENOENT, lstat ….’. The problem turned out to be my use of wildcards in the src.

In the original task below, gulp creates a list of all files and folders in the /dist folder and deletes each of them asynchronously.

[source language=”js”] gulp.task(‘clean’, function () {
return gulp.src(‘./dist/**/*’, { read: false })
.pipe(clean({force: true}));
});[/source]

Given the below folder structure, it was attempting to delete the dist/images/logo.png entry after it had already deleted the /dist/images folder.

/dist
/dist/images
/dist/images/logo.png

The solution was to remove the /dist folder itself without wildcards.

[source language=”js”] gulp.task(‘clean’, function () {
return gulp.src(‘./dist’, { read: false })
.pipe(clean({force: true}));
});[/source]

Use `del` Instead

As an aside, gulp-clean has been deprecated. It’s suggested replacement, del does seem to handle glob patterns as we would expect.

[source language=”js”] gulp.task(‘clean’, function () {
return del(‘./dist/**/*’);
});[/source]

The post gulp clean Error: ENOENT, lstat appeared first on Gemba Labs.

An operation on a socket could not be performed because the system lacked sufficient buffer space or because a queue was full

John Miller — Wed, 20 May 2015 12:30:28 +0000

I recently ran into a scenario where our cucumber tests would fail on our build server if tests within other jobs were being ran simultaneously. About halfway through, a handful of tests would consistently with the error:

An operation on a socket could not be performed because the system lacked sufficient buffer space or because a queue was full. - connect(2) (Errno::ENOBUFS)

Cucumber uses Chromedriver to communicate with Chrome over TCP/IP, using a wide range of temporary ports on the server. If your run a netstat -a from the command line while it’s running, you can see the port allocation. After a request completes, the socket is ready to close and goes into TIME_WAIT status. This gives any trailing packets time to catch up before the door closes. By default, the server keeps the socket in TIME_WAIT status for 4 minutes and is unavailable for reuse during that time.

We had enough tests running in parallel that it was exhausting the available ports after 15 minutes. Our solution was to reduce the amount of time the server kept ports in TIME_WAIT status down to 30 seconds, which is more than reasonable for our build server.

To do this, open regedit and add a new DWORD entry named TcpTimedWaitDelay in the HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters folder – giving it a DECIMAL value of 30. (Will require a reboot.)

Hopefully this saves someone else some time!

http://www.outsystems.com/forums/discussion/6956/how-to-tune-the-tcp-ip-stack-for-high-volume-of-web-requests/
https://technet.microsoft.com/en-us/library/cc938217.aspx

The post An operation on a socket could not be performed because the system lacked sufficient buffer space or because a queue was full appeared first on Gemba Labs.

Using the ASP.Net bundler without minification

John Miller — Mon, 20 Apr 2015 12:26:47 +0000

The bundler shipped with ASP.Net works pretty well with minimal configuration. In short, when the debug flag is off the bundler will do a few things for us:

Bundle related files into single web response
Apply minification transformation such as shortening variable\method names, trimming whitespace, removing comments, etc
Add a version token to the querystring of the resource filename. It recognizes when a file within a group changes and produces a new token, which will keep our users’ browsers from using cached files.

Below is a sample BundleConfig.cs file that defines four javascript bundles and a single css bundle. When debug is turned on, each of the files will be served independently.

[source language=”csharp”] public class BundleConfig
{
public static void RegisterBundles(BundleCollection bundles)
{
bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
"~/Scripts/jquery-{version}.js"));

bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
"~/Scripts/jquery.validate*"));

bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
"~/Scripts/modernizr-*"));

bundles.Add(new ScriptBundle("~/bundles/bootstrap").Include(
"~/Scripts/bootstrap.js",
"~/Scripts/respond.js"));

bundles.Add(new StyleBundle("~/Content/css").Include(
"~/Content/bootstrap.css",
"~/Content/site.css"));
}
}[/source]

Let’s turn debug off so we can see the bundler in action.

[source language=”xml” highlight=”3″]

[/source]

Looking at the Network tab in Chrome’s developer tools shows that the files are now being minified and loaded from /bundles/ url paths instead of the physical /scripts/ path. Also, now /bundles/boostrap.js includes the contents of both bootstrap.js and respond.js.

Since the minifying process involves rewriting javascript code, it’s possible that a bug could appear as a result. Luckily, if a particularly nasty bug appears, there are methods available to bypass minification while continuing to take advantage of bundling and versioning.

Our first option is to register our scripts as generic Bundle objects instead of ScriptBundles. In the sample below, we’ve changed the ‘bootstrap’ bundle from a ScriptBundle to a regular Bundle and we can see that the the bootstrap.js and respond.js files have been merged, but not minified.

[source language=”csharp” highlight=”14-16″] public class BundleConfig
{
public static void RegisterBundles(BundleCollection bundles)
{
bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
"~/Scripts/jquery-{version}.js"));

bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
"~/Scripts/jquery.validate*"));

bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
"~/Scripts/modernizr-*"));

bundles.Add(new Bundle("~/bundles/bootstrap").Include(
"~/Scripts/bootstrap.js",
"~/Scripts/respond.js"));

bundles.Add(new StyleBundle("~/Content/css").Include(
"~/Content/bootstrap.css",
"~/Content/site.css"));
}
}[/source]

This approach would allow us to configure minification on a bundle-by-bundle basic. But what if we wanted to disable it site-wide? We can do this by clearing the Transforms collection for each bundle after they’re registered in the Global.asax.cs.

[source language=”csharp” highlight=”9″] public class MvcApplication : System.Web.HttpApplication
{
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
BundleTable.Bundles.ForEach(x => x.Transforms.Clear());
}
}[/source]

Now all of our javascript resources will continued to be bundled (and versioned), but without going through the minification process!

Resources

Official Documentation
Professional ASP.NET MVC 5

The post Using the ASP.Net bundler without minification appeared first on Gemba Labs.

Elasticsearch Tutorial: What is percolation?

John Miller — Thu, 16 Apr 2015 00:35:51 +0000

One of the lesser known features in Elasticsearch search is percolation. It’s commonly referred to as “search in reverse” and it allows you to index queries and, at a later time, percolate a document to find queries that it will match. Sound a bit confusing? It took me a while to wrap my head around this feature, but once you understand how it works it’s easy to see just how powerful it can be across a wide range of domains.

For example, imagine:

A news aggregator that, instead of restricting user subscriptions to broad categories of content, it allowed them the freedom to be very specific about the type of content they’re interested in. For example, instead of simply following a ‘Sports’ category they subscribe to articles discussing the Cleveland Cavs during the weeks of the playoffs.
A regulation company needing to be notified when specific types of additives are added to our food.
A day trader who wants know when a security within the Tech sector break through their 10-day moving average.

To familiarize ourselves with the Percolator, we’re going to walk through a simple example that includes a ‘Library’ index which contains documents of type ‘Book’. The book type mapping has properties describing author, title, categories, and a list of nested locations (which will include availability information).

NOTE: The examples throughout this post were created using the Sense tool within the Marvel plugin. The query feature itself makes it worth the 15 seconds it takes to install. But if you use other tools, such as cURL, be sure to add the server and port to the url.

Ex.

CURL -XGET http://localhost:9200/library/book/1

[source language=”js”] POST library/_mapping/book
{
"book":{
"properties":{
"author":{
"type":"string"
},
"categories":{
"type":"string",
"index":"not_analyzed"
},
"id":{
"type":"integer"
},
"locations":{
"type":"nested",
"properties":{
"availableCopies":{
"type":"integer"
},
"name":{
"type":"string"
}
}
},
"title":{
"type":"string"
}
}
}
}[/source]

Given the above mapping, let’s consider a patron that wants to be notified when any books new books by Vonnegut are added. To do this, we’re going to register a query using the library index’s percolator endpoint.

Note that in the url, we’re specify the new query id, “johns_wishlist”. The message body itself has two parts: the query which includes the match criteria, and a place for storing metadata describing the query. In this example, we’re using the metadata section to store the userid for the person owning this wish list query.

[source language=”js”] POST /library/.percolator/johns_wishlist
{
"query":{
"match":{
"author":"vonnegut"
},
"userid":"1"
}
}[/source]

It’s awesome to see that, much like documents, queries are also stored in a flexible JSON format.

Now that we have a stored query, let’s percolate a document to see if we can match the query. This involves sending a message with document information to the “_percolate” endpoint. The “doc” property includes the values describing the book.

[source language=”js”] GET library/book/_percolate
{
"doc":{
"title":"Breakfast of Champions",
"author":"Kurt Vonnegut"
}
}[/source]

This request would produce the results:

[source language=”js”] {
"took":1,
"_shards":{
"total":5,
"successful":5,
"failed":0
},
"total":1,
"matches":[
{
"_index":"library",
"_id":"johns_wishlist"
}
] }[/source]

The act of percolating does not add the document itself to the index, that would need to be done as a separate step. We could, however, percolate using existing documents by including the document id in the percolate request.

[source language=”bash”] GET library/book/1/_percolate[/source]

The Percolator has several other useful features such as aggregation, sorting, highlighting, and percolating multiple documents at a time. Below are some resources available if you’d like to learn a bit more.

Official documentation – Overview of the available configuration options for the percolator.

Elasticsearch: The Definitive Guide – Most of the content covered in this book is available on the documentation site, but the book is better structured for folks (like myself) trying to learn Elasticsearch from start to finish.

The post Elasticsearch Tutorial: What is percolation? appeared first on Gemba Labs.

Updating Widows Service Bus Runas Password

John Miller — Fri, 18 Apr 2014 14:28:12 +0000

I’m running a Windows Service Bus 1.1 farm on my local machine for testing, and recently the services stopped working after I updated my system password. The services were configured to run under my user account so needed to be updated after I changed my password.

To do so, we’ll need to use Service Bus Powershell.

First, stop any services that by be running.

Stop-SBFarm

Once everything is stopped, we can update the runas password by using a SecureString.

$pw=ConvertTo-SecureString -AsPlainText -Force -String 'yourpassword'
Update-SBHost -RunAsPassword $pw

And last, we just need to restart the farm.

Start-SBFarm

The post Updating Widows Service Bus Runas Password appeared first on Gemba Labs.

Enabling WCF Trace Log

John Miller — Sat, 12 Apr 2014 22:37:05 +0000

The Tracing feature in WCF gives us the ability capture event\message details as calls are made to web services. Enabling this in IIS can be done fairly easily by selecting the Application and clicking the “Configure…” link in the Manage WCF and WF Services section of the Action panel. From there, go the Monitoring section which will allow you to configure your trace settings. You can also configure this at the website or server level as well.

You can also set this up in your application’s web.config (helpful when running under IIS Express) by adding diagnostic elements to the system.serviceModel and system.webServer sections.

The post Enabling WCF Trace Log appeared first on Gemba Labs.

Reverse engineer database to custom Code First entity model and mappings

John Miller — Fri, 21 Mar 2014 00:24:22 +0000

It’s really cool to see how far code-first support within Entity Framework has come over the last few releases. It’s extremely freeing to be create our own POCOs and custom mapping classes, which nostalgically remind of past projects with FluentNHibernate. And we aren’t tied down to edmx files (and nasty merge conflicts that come with them)!

With that freedom comes a bit of extra responsibility on our part…meaning we have to actually create those POCOs, mappers, and DbContext classes. It turns out, the Entity Framework team has created some tools to make that work a bit easier for us if we already have a database schema in place. The latest release of EF Power Tools includes a ‘Reverse Engineer Code First’ utility to generate these initial classes.

First, we need to install the latest version of the EF Power Tools VS extension using the Tools –> Extensions and Updates menu item within Visual Studio.

After installing, projects will have two new context menu items available within Visual Studio.

Reverse Engineer Code First – Given a database connection, creates the related models, mappers, and db context classes.
Customize Reverse Engineer Templates – Allows you to tailor the generation of these classes.

Let’s begin by reverse engineering a simple BookStore database containing two tables: Authors and Books. Upon selecting, we’re asked for database connection information which, once entered, will be used to generate those classes.

Depending on the size of your database, this step could take up to a couple minutes. Below are the classes generated.

Let’s take a look at one of the mappers.

[source language=”csharp”] public class BookMap : EntityTypeConfiguration
{
public BookMap()
{
// Primary Key
this.HasKey(t => t.Id);

// Properties
this.Property(t => t.Title)
.IsRequired()
.HasMaxLength(50);

// Table & Column Mappings
this.ToTable("Books");
this.Property(t => t.Id).HasColumnName("Id");
this.Property(t => t.Title).HasColumnName("Title");
this.Property(t => t.AuthorId).HasColumnName("AuthorId");

// Relationships
this.HasRequired(t => t.Author)
.WithMany(t => t.Books)
.HasForeignKey(d => d.AuthorId);
}
}[/source]

The generated code isn’t bad, but I’d like it to be a little cleaner. Luckily, we can modify how these are created by tweaking the T4 templates used to generate our model. The remaining cleanup can be done using Resharper. Let’s delete the Models folder and start over.

Right-click the VS project and select Entity Framework –> Customize Reverse Engineer Templates. If you receive the following prompt, click OK.

Open Solution Explorer, and you should see the following T4 templates added to the project. (You can ignore the errors that VS says exists in the templates, they won’t actually stop the project from building…and we’ll be deleting the templates after generating our model).

I made the following changes to the generated templates:

Removed ‘partial’ keyword from entity and context classes
Removed ‘this’ qualifier throughout
Combined property mapping configuration

Now, we can run the Reverse Engineer tool again and this time we’ll get a slightly cleaner BookMap class.

[source language=”csharp”] public class BookMap : EntityTypeConfiguration
{
public BookMap()
{
HasKey(t => t.Id);
ToTable("Books");

Property(t => t.Id)
.HasColumnName("Id");

Property(t => t.Title)
.HasColumnName("Title")
.IsRequired()
.HasMaxLength(50);

Property(t => t.AuthorId)
.HasColumnName("AuthorId");

HasRequired(t => t.Author)
.WithMany(t => t.Books)
.HasForeignKey(d => d.AuthorId);
}
}[/source]

We didn’t do it here, but we could have modified the templates for other reasons as well. For example, we could have made all of our entities (or mappers) inherit from a common base class. Or we could have appended a ‘Dto’ suffix to the end of our model classes.

These templates are available on github.
https://github.com/johnmiller/ReverseEngineerCodeFirstT4Templates

The post Reverse engineer database to custom Code First entity model and mappings appeared first on Gemba Labs.